home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / bdb.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  18.5 KB  |  590 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import sys
  5. import os
  6. import types
  7. __all__ = [
  8.     'BdbQuit',
  9.     'Bdb',
  10.     'Breakpoint']
  11.  
  12. class BdbQuit(Exception):
  13.     pass
  14.  
  15.  
  16. class Bdb:
  17.     
  18.     def __init__(self):
  19.         self.breaks = { }
  20.         self.fncache = { }
  21.  
  22.     
  23.     def canonic(self, filename):
  24.         if filename == '<' + filename[1:-1] + '>':
  25.             return filename
  26.         
  27.         canonic = self.fncache.get(filename)
  28.         if not canonic:
  29.             canonic = os.path.abspath(filename)
  30.             canonic = os.path.normcase(canonic)
  31.             self.fncache[filename] = canonic
  32.         
  33.         return canonic
  34.  
  35.     
  36.     def reset(self):
  37.         import linecache
  38.         linecache.checkcache()
  39.         self.botframe = None
  40.         self.stopframe = None
  41.         self.returnframe = None
  42.         self.quitting = 0
  43.  
  44.     
  45.     def trace_dispatch(self, frame, event, arg):
  46.         if self.quitting:
  47.             return None
  48.         
  49.         if event == 'line':
  50.             return self.dispatch_line(frame)
  51.         
  52.         if event == 'call':
  53.             return self.dispatch_call(frame, arg)
  54.         
  55.         if event == 'return':
  56.             return self.dispatch_return(frame, arg)
  57.         
  58.         if event == 'exception':
  59.             return self.dispatch_exception(frame, arg)
  60.         
  61.         print 'bdb.Bdb.dispatch: unknown debugging event:', `event`
  62.         return self.trace_dispatch
  63.  
  64.     
  65.     def dispatch_line(self, frame):
  66.         if self.stop_here(frame) or self.break_here(frame):
  67.             self.user_line(frame)
  68.             if self.quitting:
  69.                 raise BdbQuit
  70.             
  71.         
  72.         return self.trace_dispatch
  73.  
  74.     
  75.     def dispatch_call(self, frame, arg):
  76.         if self.botframe is None:
  77.             self.botframe = frame.f_back
  78.             return self.trace_dispatch
  79.         
  80.         if not self.stop_here(frame):
  81.             pass
  82.         if not self.break_anywhere(frame):
  83.             return None
  84.         
  85.         self.user_call(frame, arg)
  86.         if self.quitting:
  87.             raise BdbQuit
  88.         
  89.         return self.trace_dispatch
  90.  
  91.     
  92.     def dispatch_return(self, frame, arg):
  93.         if self.stop_here(frame) or frame == self.returnframe:
  94.             self.user_return(frame, arg)
  95.             if self.quitting:
  96.                 raise BdbQuit
  97.             
  98.         
  99.         return self.trace_dispatch
  100.  
  101.     
  102.     def dispatch_exception(self, frame, arg):
  103.         if self.stop_here(frame):
  104.             self.user_exception(frame, arg)
  105.             if self.quitting:
  106.                 raise BdbQuit
  107.             
  108.         
  109.         return self.trace_dispatch
  110.  
  111.     
  112.     def stop_here(self, frame):
  113.         if frame is self.stopframe:
  114.             return True
  115.         
  116.         while frame is not None and frame is not self.stopframe:
  117.             if frame is self.botframe:
  118.                 return True
  119.             
  120.             frame = frame.f_back
  121.         return False
  122.  
  123.     
  124.     def break_here(self, frame):
  125.         filename = self.canonic(frame.f_code.co_filename)
  126.         if not (filename in self.breaks):
  127.             return False
  128.         
  129.         lineno = frame.f_lineno
  130.         if not (lineno in self.breaks[filename]):
  131.             return False
  132.         
  133.         (bp, flag) = effective(filename, lineno, frame)
  134.         if bp:
  135.             self.currentbp = bp.number
  136.             if flag and bp.temporary:
  137.                 self.do_clear(str(bp.number))
  138.             
  139.             return True
  140.         else:
  141.             return False
  142.  
  143.     
  144.     def do_clear(self, arg):
  145.         raise NotImplementedError, 'subclass of bdb must implement do_clear()'
  146.  
  147.     
  148.     def break_anywhere(self, frame):
  149.         return self.breaks.has_key(self.canonic(frame.f_code.co_filename))
  150.  
  151.     
  152.     def user_call(self, frame, argument_list):
  153.         pass
  154.  
  155.     
  156.     def user_line(self, frame):
  157.         pass
  158.  
  159.     
  160.     def user_return(self, frame, return_value):
  161.         pass
  162.  
  163.     
  164.     def user_exception(self, frame, .4):
  165.         (exc_type, exc_value, exc_traceback) = .4
  166.  
  167.     
  168.     def set_step(self):
  169.         self.stopframe = None
  170.         self.returnframe = None
  171.         self.quitting = 0
  172.  
  173.     
  174.     def set_next(self, frame):
  175.         self.stopframe = frame
  176.         self.returnframe = None
  177.         self.quitting = 0
  178.  
  179.     
  180.     def set_return(self, frame):
  181.         self.stopframe = frame.f_back
  182.         self.returnframe = frame
  183.         self.quitting = 0
  184.  
  185.     
  186.     def set_trace(self):
  187.         frame = sys._getframe().f_back
  188.         self.reset()
  189.         while frame:
  190.             frame.f_trace = self.trace_dispatch
  191.             self.botframe = frame
  192.             frame = frame.f_back
  193.         self.set_step()
  194.         sys.settrace(self.trace_dispatch)
  195.  
  196.     
  197.     def set_continue(self):
  198.         self.stopframe = self.botframe
  199.         self.returnframe = None
  200.         self.quitting = 0
  201.         if not (self.breaks):
  202.             sys.settrace(None)
  203.             frame = sys._getframe().f_back
  204.             while frame and frame is not self.botframe:
  205.                 del frame.f_trace
  206.                 frame = frame.f_back
  207.         
  208.  
  209.     
  210.     def set_quit(self):
  211.         self.stopframe = self.botframe
  212.         self.returnframe = None
  213.         self.quitting = 1
  214.         sys.settrace(None)
  215.  
  216.     
  217.     def set_break(self, filename, lineno, temporary = 0, cond = None):
  218.         filename = self.canonic(filename)
  219.         import linecache
  220.         line = linecache.getline(filename, lineno)
  221.         if not line:
  222.             return 'Line %s:%d does not exist' % (filename, lineno)
  223.         
  224.         if not (filename in self.breaks):
  225.             self.breaks[filename] = []
  226.         
  227.         list = self.breaks[filename]
  228.         if not (lineno in list):
  229.             list.append(lineno)
  230.         
  231.         bp = Breakpoint(filename, lineno, temporary, cond)
  232.  
  233.     
  234.     def clear_break(self, filename, lineno):
  235.         filename = self.canonic(filename)
  236.         if not (filename in self.breaks):
  237.             return 'There are no breakpoints in %s' % filename
  238.         
  239.         if lineno not in self.breaks[filename]:
  240.             return 'There is no breakpoint at %s:%d' % (filename, lineno)
  241.         
  242.         for bp in Breakpoint.bplist[(filename, lineno)][:]:
  243.             bp.deleteMe()
  244.         
  245.         if not Breakpoint.bplist.has_key((filename, lineno)):
  246.             self.breaks[filename].remove(lineno)
  247.         
  248.         if not self.breaks[filename]:
  249.             del self.breaks[filename]
  250.         
  251.  
  252.     
  253.     def clear_bpbynumber(self, arg):
  254.         
  255.         try:
  256.             number = int(arg)
  257.         except:
  258.             return 'Non-numeric breakpoint number (%s)' % arg
  259.  
  260.         
  261.         try:
  262.             bp = Breakpoint.bpbynumber[number]
  263.         except IndexError:
  264.             return 'Breakpoint number (%d) out of range' % number
  265.  
  266.         if not bp:
  267.             return 'Breakpoint (%d) already deleted' % number
  268.         
  269.         self.clear_break(bp.file, bp.line)
  270.  
  271.     
  272.     def clear_all_file_breaks(self, filename):
  273.         filename = self.canonic(filename)
  274.         if not (filename in self.breaks):
  275.             return 'There are no breakpoints in %s' % filename
  276.         
  277.         for line in self.breaks[filename]:
  278.             blist = Breakpoint.bplist[(filename, line)]
  279.             for bp in blist:
  280.                 bp.deleteMe()
  281.             
  282.         
  283.         del self.breaks[filename]
  284.  
  285.     
  286.     def clear_all_breaks(self):
  287.         if not (self.breaks):
  288.             return 'There are no breakpoints'
  289.         
  290.         for bp in Breakpoint.bpbynumber:
  291.             if bp:
  292.                 bp.deleteMe()
  293.                 continue
  294.         
  295.         self.breaks = { }
  296.  
  297.     
  298.     def get_break(self, filename, lineno):
  299.         filename = self.canonic(filename)
  300.         if filename in self.breaks:
  301.             pass
  302.         return lineno in self.breaks[filename]
  303.  
  304.     
  305.     def get_breaks(self, filename, lineno):
  306.         filename = self.canonic(filename)
  307.         if not filename in self.breaks and lineno in self.breaks[filename] and Breakpoint.bplist[(filename, lineno)]:
  308.             pass
  309.         return []
  310.  
  311.     
  312.     def get_file_breaks(self, filename):
  313.         filename = self.canonic(filename)
  314.         if filename in self.breaks:
  315.             return self.breaks[filename]
  316.         else:
  317.             return []
  318.  
  319.     
  320.     def get_all_breaks(self):
  321.         return self.breaks
  322.  
  323.     
  324.     def get_stack(self, f, t):
  325.         stack = []
  326.         if t and t.tb_frame is f:
  327.             t = t.tb_next
  328.         
  329.         while f is not None:
  330.             stack.append((f, f.f_lineno))
  331.             if f is self.botframe:
  332.                 break
  333.             
  334.             f = f.f_back
  335.         stack.reverse()
  336.         i = max(0, len(stack) - 1)
  337.         while t is not None:
  338.             stack.append((t.tb_frame, t.tb_lineno))
  339.             t = t.tb_next
  340.         return (stack, i)
  341.  
  342.     
  343.     def format_stack_entry(self, frame_lineno, lprefix = ': '):
  344.         import linecache
  345.         import repr
  346.         (frame, lineno) = frame_lineno
  347.         filename = self.canonic(frame.f_code.co_filename)
  348.         s = filename + '(' + `lineno` + ')'
  349.         if frame.f_code.co_name:
  350.             s = s + frame.f_code.co_name
  351.         else:
  352.             s = s + '<lambda>'
  353.         if '__args__' in frame.f_locals:
  354.             args = frame.f_locals['__args__']
  355.         else:
  356.             args = None
  357.         if args:
  358.             s = s + repr.repr(args)
  359.         else:
  360.             s = s + '()'
  361.         if '__return__' in frame.f_locals:
  362.             rv = frame.f_locals['__return__']
  363.             s = s + '->'
  364.             s = s + repr.repr(rv)
  365.         
  366.         line = linecache.getline(filename, lineno)
  367.         if line:
  368.             s = s + lprefix + line.strip()
  369.         
  370.         return s
  371.  
  372.     
  373.     def run(self, cmd, globals = None, locals = None):
  374.         if globals is None:
  375.             import __main__
  376.             globals = __main__.__dict__
  377.         
  378.         if locals is None:
  379.             locals = globals
  380.         
  381.         self.reset()
  382.         sys.settrace(self.trace_dispatch)
  383.         if not isinstance(cmd, types.CodeType):
  384.             cmd = cmd + '\n'
  385.         
  386.         
  387.         try:
  388.             exec cmd in globals, locals
  389.         except BdbQuit:
  390.             pass
  391.         finally:
  392.             self.quitting = 1
  393.             sys.settrace(None)
  394.  
  395.  
  396.     
  397.     def runeval(self, expr, globals = None, locals = None):
  398.         if globals is None:
  399.             import __main__
  400.             globals = __main__.__dict__
  401.         
  402.         if locals is None:
  403.             locals = globals
  404.         
  405.         self.reset()
  406.         sys.settrace(self.trace_dispatch)
  407.         if not isinstance(expr, types.CodeType):
  408.             expr = expr + '\n'
  409.         
  410.         
  411.         try:
  412.             return eval(expr, globals, locals)
  413.         except BdbQuit:
  414.             pass
  415.         finally:
  416.             self.quitting = 1
  417.             sys.settrace(None)
  418.  
  419.  
  420.     
  421.     def runctx(self, cmd, globals, locals):
  422.         self.run(cmd, globals, locals)
  423.  
  424.     
  425.     def runcall(self, func, *args):
  426.         self.reset()
  427.         sys.settrace(self.trace_dispatch)
  428.         res = None
  429.         
  430.         try:
  431.             res = func(*args)
  432.         except BdbQuit:
  433.             pass
  434.         finally:
  435.             self.quitting = 1
  436.             sys.settrace(None)
  437.  
  438.         return res
  439.  
  440.  
  441.  
  442. def set_trace():
  443.     Bdb().set_trace()
  444.  
  445.  
  446. class Breakpoint:
  447.     next = 1
  448.     bplist = { }
  449.     bpbynumber = [
  450.         None]
  451.     
  452.     def __init__(self, file, line, temporary = 0, cond = None):
  453.         self.file = file
  454.         self.line = line
  455.         self.temporary = temporary
  456.         self.cond = cond
  457.         self.enabled = 1
  458.         self.ignore = 0
  459.         self.hits = 0
  460.         self.number = Breakpoint.next
  461.         Breakpoint.next = Breakpoint.next + 1
  462.         self.bpbynumber.append(self)
  463.         if self.bplist.has_key((file, line)):
  464.             self.bplist[(file, line)].append(self)
  465.         else:
  466.             self.bplist[(file, line)] = [
  467.                 self]
  468.  
  469.     
  470.     def deleteMe(self):
  471.         index = (self.file, self.line)
  472.         self.bpbynumber[self.number] = None
  473.         self.bplist[index].remove(self)
  474.         if not self.bplist[index]:
  475.             del self.bplist[index]
  476.         
  477.  
  478.     
  479.     def enable(self):
  480.         self.enabled = 1
  481.  
  482.     
  483.     def disable(self):
  484.         self.enabled = 0
  485.  
  486.     
  487.     def bpprint(self):
  488.         if self.temporary:
  489.             disp = 'del  '
  490.         else:
  491.             disp = 'keep '
  492.         if self.enabled:
  493.             disp = disp + 'yes'
  494.         else:
  495.             disp = disp + 'no '
  496.         print '%-4dbreakpoint    %s at %s:%d' % (self.number, disp, self.file, self.line)
  497.         if self.cond:
  498.             print '\tstop only if %s' % (self.cond,)
  499.         
  500.         if self.ignore:
  501.             print '\tignore next %d hits' % self.ignore
  502.         
  503.         if self.hits:
  504.             if self.hits > 1:
  505.                 ss = 's'
  506.             else:
  507.                 ss = ''
  508.             print '\tbreakpoint already hit %d time%s' % (self.hits, ss)
  509.         
  510.  
  511.  
  512.  
  513. def effective(file, line, frame):
  514.     possibles = Breakpoint.bplist[(file, line)]
  515.     for i in range(0, len(possibles)):
  516.         b = possibles[i]
  517.         if b.enabled == 0:
  518.             continue
  519.         
  520.         b.hits = b.hits + 1
  521.         if not (b.cond):
  522.             if b.ignore > 0:
  523.                 b.ignore = b.ignore - 1
  524.                 continue
  525.             else:
  526.                 return (b, 1)
  527.         b.ignore > 0
  528.         
  529.         try:
  530.             val = eval(b.cond, frame.f_globals, frame.f_locals)
  531.             if val:
  532.                 if b.ignore > 0:
  533.                     b.ignore = b.ignore - 1
  534.                 else:
  535.                     return (b, 1)
  536.         continue
  537.         return (b, 0)
  538.         continue
  539.  
  540.     
  541.     return (None, None)
  542.  
  543.  
  544. class Tdb(Bdb):
  545.     
  546.     def user_call(self, frame, args):
  547.         name = frame.f_code.co_name
  548.         if not name:
  549.             name = '???'
  550.         
  551.         print '+++ call', name, args
  552.  
  553.     
  554.     def user_line(self, frame):
  555.         import linecache
  556.         name = frame.f_code.co_name
  557.         if not name:
  558.             name = '???'
  559.         
  560.         fn = self.canonic(frame.f_code.co_filename)
  561.         line = linecache.getline(fn, frame.f_lineno)
  562.         print '+++', fn, frame.f_lineno, name, ':', line.strip()
  563.  
  564.     
  565.     def user_return(self, frame, retval):
  566.         print '+++ return', retval
  567.  
  568.     
  569.     def user_exception(self, frame, exc_stuff):
  570.         print '+++ exception', exc_stuff
  571.         self.set_continue()
  572.  
  573.  
  574.  
  575. def foo(n):
  576.     print 'foo(', n, ')'
  577.     x = bar(n * 10)
  578.     print 'bar returned', x
  579.  
  580.  
  581. def bar(a):
  582.     print 'bar(', a, ')'
  583.     return a / 2
  584.  
  585.  
  586. def test():
  587.     t = Tdb()
  588.     t.run('import bdb; bdb.foo(10)')
  589.  
  590.